#ifndef __TASK_QUEUE_H__
#define __TASK_QUEUE_H__
#include "../../../log/systemLog/systemLog.h"
#include "../../../sessionManager/sessionManager.h"

// 任务节点
typedef struct task_node_s
{
    user_session_t *session;  // 用户会话指针
    struct task_node_s *next; // 指向下一个任务节点的指针
} task_node_t;

// 任务队列
typedef struct task_queue_s
{
    task_node_t *front; // 队列头指针
    task_node_t *rear;  // 队列尾指针
    int size;           // 队列大小
} task_queue_t;

/**
 * @brief 初始化任务队列
 *
 * @param queue 需要初始化的任务队列指针
 * @return int 初始化结果，成功返回 SYSTEM_ERR_OK，参数错误返回 SYSTEM_ERR_INVALID_ARGUMENT
 */
int task_queue_init(task_queue_t *queue);

/**
 * @brief 创建一个新的任务节点
 *
 * @param session 用户会话指针
 * @param new_node 输出参数，指向新创建的任务节点指针
 * @return int 创建结果，成功返回 SYSTEM_ERR_OK，参数错误返回 SYSTEM_ERR_INVALID_ARGUMENT，内存分配失败返回 SYSTEM_ERR_OUT_OF_MEMORY
 */
int task_node_create(user_session_t *session, task_node_t **new_node);

/**
 * @brief 将任务节点加入任务队列
 *
 * @param queue 任务队列指针
 * @param node 任务节点指针
 * @return int 入队结果，成功返回 SYSTEM_ERR_OK，参数错误返回 SYSTEM_ERR_INVALID_ARGUMENT
 */
int enqueue_task(task_queue_t *queue, task_node_t *node);

/**
 * @brief 从任务队列中取出一个任务节点
 *
 * @param queue 任务队列指针
 * @param node 输出参数，指向取出的任务节点指针
 * @return int 出队结果，成功返回 SYSTEM_ERR_OK，参数错误返回 SYSTEM_ERR_INVALID_ARGUMENT，队列为空返回 SYSTEM_ERR_QUEUE_EMPTY
 */
int dequeue_task(task_queue_t *queue, task_node_t **node);

// 这些宏仅记录错误，不改变控制流。调用者仍需根据返回值处理。
// init 返回值检查：-1 参数错误
#define TASK_QUEUE_CHECK_INIT(ret)                                            \
    do                                                                        \
    {                                                                         \
        system_error_code_t _ret = (ret);                                     \
        if (_ret != SYSTEM_ERR_OK)                                            \
        {                                                                     \
            system_error_code_t _serr = (_ret == SYSTEM_ERR_INVALID_ARGUMENT) \
                                            ? SYSTEM_ERR_INVALID_ARGUMENT     \
                                            : SYSTEM_ERR_QUEUE_INVALID;       \
            SYSTEM_LOG_ERROR(_serr, "task_queue_init failed ret=%d", _ret);   \
        }                                                                     \
    } while (0)

// task_node_create 返回值检查：-1 参数错误, -2 内存分配失败
#define TASK_NODE_CREATE_CHECK(ret)                                          \
    do                                                                       \
    {                                                                        \
        system_error_code_t _ret = (ret);                                    \
        if (_ret != SYSTEM_ERR_OK)                                           \
        {                                                                    \
            system_error_code_t _serr = (_ret == SYSTEM_ERR_OUT_OF_MEMORY)   \
                                            ? SYSTEM_ERR_OUT_OF_MEMORY       \
                                            : SYSTEM_ERR_INVALID_ARGUMENT;   \
            SYSTEM_LOG_ERROR(_serr, "task_node_create failed ret=%d", _ret); \
        }                                                                    \
    } while (0)

// enqueue_task 返回值检查：-1 参数错误
#define ENQUEUE_TASK_CHECK(ret)                                          \
    do                                                                   \
    {                                                                    \
        system_error_code_t _ret = (ret);                                \
        if (_ret != SYSTEM_ERR_OK)                                       \
        {                                                                \
            system_error_code_t _serr = SYSTEM_ERR_INVALID_ARGUMENT;     \
            SYSTEM_LOG_ERROR(_serr, "enqueue_task failed ret=%d", _ret); \
        }                                                                \
    } while (0)

// dequeue_task 返回值检查：-1 参数错误, -2 队列为空
#define DEQUEUE_TASK_CHECK(ret)                                            \
    do                                                                     \
    {                                                                      \
        system_error_code_t _ret = (ret);                                  \
        if (_ret != SYSTEM_ERR_OK)                                         \
        {                                                                  \
            system_error_code_t _serr = (_ret == SYSTEM_ERR_QUEUE_EMPTY)   \
                                            ? SYSTEM_ERR_QUEUE_EMPTY       \
                                            : SYSTEM_ERR_INVALID_ARGUMENT; \
            SYSTEM_LOG_ERROR(_serr, "dequeue_task failed ret=%d", _ret);   \
        }                                                                  \
    } while (0)

#endif // __TASK_QUEUE_H__